package com.iot.core.utils;

import org.apache.commons.lang3.StringUtils;

import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Optional;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @ClassName StringUtil
 * @Description
 * @Author DuWei
 * @Date 2019/1/17 16:18
 **/
public class StringUtil {
    /**
     * 判断是否是一个中文汉字
     *
     * @param c 字符
     * @return true表示是中文汉字，false表示是英文字母
     * @throws UnsupportedEncodingException 使用了JAVA不支持的编码格式
     */
    public static boolean isChineseChar(char c)
            throws UnsupportedEncodingException {

        // 如果字节数大于1，是汉字
        // 以这种方式区别英文字母和中文汉字并不是十分严谨，但在这个题目中，这样判断已经足够了
        return String.valueOf(c).getBytes("utf-8").length > 1;
    }

    /**
     * 计算当前String字符串所占的总Byte长度
     *
     * @param args 要截取的字符串
     * @return 返回值int型，字符串所占的字节长度，如果args为空或者“”则返回0
     * @throws UnsupportedEncodingException
     */
    public static int getStringByteLenths(String args) throws UnsupportedEncodingException {
        return args != null && args != "" ? args.getBytes("utf-8").length : 0;
    }

    /**
     * 获取与字符串每一个char对应的字节长度数组
     *
     * @param args 要计算的目标字符串
     * @return int[]
     * 数组类型，返回与字符串每一个char对应的字节长度数组
     * @throws UnsupportedEncodingException
     */
    public static int[] getByteLenArrays(String args) throws UnsupportedEncodingException {
        char[] strlen = args.toCharArray();
        int[] charlen = new int[strlen.length];
        for (int i = 0; i < strlen.length; i++) {
            charlen[i] = String.valueOf(strlen[i]).getBytes("utf-8").length;
        }
        return charlen;
    }

    /**
     * 按字节截取字符串 ，指定截取起始字节位置与截取字节长度
     *
     * @param orignal 要截取的字符串
     * @param count   截取Byte长度；
     * @return 截取后的字符串
     * @throws UnsupportedEncodingException 使用了JAVA不支持的编码格式
     */
    public static String substringByte(String orignal, int start, int count) {

        //如果目标字符串为空，则直接返回，不进入截取逻辑；
        if (orignal == null || "".equals(orignal)) return "";

        //截取Byte长度必须>0
        if (count <= 0) return orignal;

        //截取的起始字节数必须比
        if (start < 0) start = 0;

        //目标char Pull buff缓存区间；
        StringBuffer buff = new StringBuffer();

        try {

            //截取字节起始字节位置大于目标String的Byte的length则返回空值
            if (start >= getStringByteLenths(orignal)) return null;

            // int[] arrlen=getByteLenArrays(orignal);
            int len = 0;

            char c;

            //遍历String的每一个Char字符，计算当前总长度
            //如果到当前Char的的字节长度大于要截取的字符总长度，则跳出循环返回截取的字符串。
            for (int i = 0; i < orignal.toCharArray().length; i++) {

                c = orignal.charAt(i);

                //当起始位置为0时候
                if (start == 0) {

                    len += String.valueOf(c).getBytes("utf-8").length;
                    if (len <= count) buff.append(c);
                    else break;

                } else {

                    //截取字符串从非0位置开始
                    len += String.valueOf(c).getBytes("utf-8").length;
                    if (len >= start && len <= start + count) {
                        buff.append(c);
                    }
                    if (len > start + count) break;

                }
            }

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        //返回最终截取的字符结果;
        //创建String对象，传入目标char Buff对象
        return new String(buff);
    }

    /**
     * 截取指定长度字符串
     *
     * @param orignal 要截取的目标字符串
     * @param count   指定截取长度
     * @return 返回截取后的字符串
     */
    public static String substringByte(String orignal, int count) {
        return substringByte(orignal, 0, count);
    }

    /**
     * 拼接字符串
     *
     * @param args
     * @return
     */
    public static String mergeString(String... args) {
        StringBuilder sb = new StringBuilder();
        for (String str : args) {
            if (StringUtils.isNotBlank(str)) {
                sb.append(str);
            }
        }
        return sb.toString();
    }

    /**
     * 判断对象是否为空并转化成空白字符串
     *
     * @param object
     * @return
     */
    public static String null2Space(Object object) {
        if (object == null) {
            return "";
        }
        return object.toString();
    }

    /**
     * 将无效数字转化为字符串0
     *
     * @param str
     * @return
     */
    public static String null2Zero(String str) {
        if (StringUtils.isBlank(str)) {
            return "0";
        } else {
            try {
                Integer.parseInt(str);
            } catch (Exception e) {
                return "0";
            }
            return str;
        }
    }

    /**
     * 正则匹配出所有结果到一个String数组中
     *
     * @param pattern
     * @param Sourcecode
     * @return
     */
    public static String[] getRegResult(String pattern, String Sourcecode) {
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(Sourcecode);
        ArrayList<String> tempList = new ArrayList<>();
        while (m.find()) {
            tempList.add(m.group());
        }
        String[] res = new String[tempList.size()];
        int i = 0;
        for (String temp : tempList) {
            res[i] = temp;
            i++;
        }
        return res;
    }

    /***
     * 下划线命名转为驼峰命名
     *
     * @param para
     *        下划线命名的字符串
     */

    public static String underlineToHump(String para) {
        StringBuilder result = new StringBuilder();
        String a[] = para.split("_");
        for (String s : a) {
            if (!para.contains("_")) {
                result.append(s);
                continue;
            }
            if (result.length() == 0) {
                result.append(s.toLowerCase());
            } else {
                result.append(s.substring(0, 1).toUpperCase());
                result.append(s.substring(1).toLowerCase());
            }
        }
        return result.toString();
    }


    /***
     * 驼峰命名转为下划线命名
     *
     * @param para
     *        驼峰命名的字符串
     */

    public static String humpToUnderline(String para) {
        if (null == para)
            return null;
        StringBuilder sb = new StringBuilder(para);
        int temp = 0;//定位
        if (!para.contains("_")) {
            for (int i = 0; i < para.length(); i++) {
                if (Character.isUpperCase(para.charAt(i))) {
                    sb.insert(i + temp, "_");
                    temp += 1;
                }
            }
        }
        return sb.toString().toLowerCase();
    }

    /**
     * 字符串为空则返回指定字符串
     *
     * @return
     */
    public static String emptyToTarget(String resource, String target) {
        if (StringUtils.isBlank(resource)) {
            return target;
        } else {
            return resource;
        }
    }
}
